﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Corona.TagToolkit
{
    public class TagJar
    {
        List<Pair<Tag, long>> relations;

        public List<Pair<Tag, long>> Relations
        {
            get { return relations; }
            set { relations = value; }
        }

        public void Add(Tag tag, long weight)
        {
            relations.Add(new Pair<Tag, long>(tag, weight));
        }
        public static implicit operator Corona.TagContract.TagJar(Corona.TagToolkit.TagJar tagjar)
        {
            return convert(tagjar);
        }

        public static Corona.TagContract.TagJar convert(Corona.TagToolkit.TagJar tagjar)
        {
            if (tagjar == null)
                return null;
            Corona.TagContract.TagJar jar = new Corona.TagContract.TagJar();
            List<Corona.TagContract.Pair<Corona.TagContract.Tag, long>> Relations = new List<Corona.TagContract.Pair<Corona.TagContract.Tag, long>>();
            foreach (Corona.TagToolkit.Pair<Corona.TagToolkit.Tag, long> par in tagjar.relations)
            {
                Corona.TagContract.Pair<Corona.TagContract.Tag, long> p = new Corona.TagContract.Pair<Corona.TagContract.Tag, long>();
                p.A = par.A;
                p.B = par.B;
                Relations.Add(p);
            }

            jar.Relations = Relations.ToArray();
            return jar;
        }

        public static Corona.TagToolkit.TagJar convert(Corona.TagContract.TagJar tagjar)
        {
            Corona.TagToolkit.TagJar jar = new Corona.TagToolkit.TagJar();
            List<Corona.TagToolkit.Pair<Corona.TagToolkit.Tag, long>> Relations = new List<Corona.TagToolkit.Pair<Corona.TagToolkit.Tag, long>>();
            foreach (Corona.TagContract.Pair<Corona.TagContract.Tag, long> par in tagjar.Relations)
            {
                Corona.TagToolkit.Pair<Corona.TagToolkit.Tag, long> p = new Corona.TagToolkit.Pair<Corona.TagToolkit.Tag, long>();
                p.A = new Tag(par.A.Name, par.A.Value);
                p.B = par.B;
                Relations.Add(p);
            }

            jar.Relations = Relations;
            return jar;
        }

        public override bool Equals(object obj)
        {
            TagJar jar = obj as TagJar;
            if (jar == null || this.relations.Count != jar.relations.Count)
                return false;
            else
            {
                IEnumerator<Pair<Tag, long>> jarIter = jar.relations.GetEnumerator();
                IEnumerator<Pair<Tag, long>> thisIter = this.relations.GetEnumerator();
                while (jarIter.MoveNext() && thisIter.MoveNext())
                    if (!jarIter.Current.Equals(thisIter.Current))
                        return false;
            }
            return true;
        }

        public override int GetHashCode()
        {
            return relations.GetHashCode();
        }

        public override string ToString()
        {
            string resault = "";
            foreach (Pair<Tag, long> par in relations)
                resault += par.ToString() + ";";
            return resault;
        }
    }
}
